Inside Macintosh: 3D Graphics Programming With QuickDraw 3D /

Chapter 20 - QuickDraw 3D Mathematical Utilities

Summary of QuickDraw 3D Mathematical Utilities

C Summary

Constants

Real Zero Definition

#ifdef FLT_EPSILON
#  define kQ3RealZero      (FLT_EPSILON)
#else
#  define kQ3RealZero      ((float)1.19209290e-07)
#endif

Maximum Floating-Point Value

#ifdef FLT_MAX
#  define kQ3MaxFloat      (FLT_MAX)
#else
#  define kQ3MaxFloat      ((float)3.40282347e+38)
#endif

Pi

#define kQ3Pi              (3.1415926535898)
#define kQ32Pi             (2.0 * kQ3Pi)

Data Types

Bounding Boxes and Spheres

typedef struct TQ3BoundingBox {
   TQ3Point3D                 min;
   TQ3Point3D                 max;
   TQ3Boolean                 isEmpty;
} TQ3BoundingBox;
typedef struct TQ3BoundingSphere {
   TQ3Point3D                 origin;
   float                      radius;
   TQ3Boolean                 isEmpty;
} TQ3BoundingSphere;

QuickDraw 3D Mathematical Utilities

Setting Points and Vectors

TQ3Point2D *Q3Point2D_Set(TQ3Point2D *point2D, float x, float y);
TQ3Param2D *Q3Param2D_Set(TQ3Param2D *param2D, float u, float v);
TQ3Point3D *Q3Point3D_Set(TQ3Point3D *point3D, 
float x, 
float y, 
float z);
TQ3RationalPoint3D *Q3RationalPoint3D_Set (
TQ3RationalPoint3D *point3D, 
float x, 
float y, 
float w);
TQ3RationalPoint4D *Q3RationalPoint4D_Set (
TQ3RationalPoint4D *point4D, 
float x, 
float y, 
float z, 
float w);
TQ3PolarPoint *Q3PolarPoint_Set (
TQ3PolarPoint *polarPoint, 
float r, 
float theta);
TQ3SphericalPoint *Q3SphericalPoint_Set (
TQ3SphericalPoint *sphericalPoint, 
float rho, 
float theta, 
float phi);
TQ3Vector2D *Q3Vector2D_Set(TQ3Vector2D *vector2D, 
float x, 
float y);
TQ3Vector3D *Q3Vector3D_Set(TQ3Vector3D *vector3D, 
float x, 
float y, 
float z);

Converting Dimensions of Points and Vectors

TQ3Point3D *Q3Point2D_To3D(const TQ3Point2D *point2D, 
TQ3Point3D *result);
TQ3RationalPoint4D *Q3Point3D_To4D (
const TQ3Point3D *point3D, 
TQ3RationalPoint4D *result);
TQ3Point2D *Q3RationalPoint3D_To2D (
const TQ3RationalPoint3D *point3D, 
TQ3Point2D *result);
TQ3Point3D *Q3RationalPoint4D_To3D (
const TQ3RationalPoint4D *point4D, 
TQ3Point3D *result);
TQ3Vector3D *Q3Vector2D_To3D(const TQ3Vector2D *vector2D, 
TQ3Vector3D *result);
TQ3Vector2D *Q3Vector3D_To2D(const TQ3Vector3D *vector3D, 
TQ3Vector2D *result);

Subtracting Points

TQ3Vector2D *Q3Point2D_Subtract (
const TQ3Point2D *p1, 
const TQ3Point2D *p2, 
TQ3Vector2D *result);
TQ3Vector2D *Q3Param2D_Subtract (
const TQ3Param2D *p1, 
const TQ3Param2D *p2, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Point3D_Subtract (
const TQ3Point3D *p1, 
const TQ3Point3D *p2, 
TQ3Vector3D *result);

Calculating Distances Between Points

float Q3Point2D_Distance(const TQ3Point2D *p1, const TQ3Point2D *p2);
float Q3Param2D_Distance(const TQ3Param2D *p1, const TQ3Param2D *p2);
float Q3Point3D_Distance(const TQ3Point3D *p1, const TQ3Point3D *p2);
float Q3RationalPoint3D_Distance (
const TQ3RationalPoint3D *p1, 
const TQ3RationalPoint3D *p2);
float Q3RationalPoint4D_Distance (
const TQ3RationalPoint4D *p1, 
const TQ3RationalPoint4D *p2);
float Q3Point2D_DistanceSquared(const TQ3Point2D *p1, const TQ3Point2D *p2);
float Q3Param2D_DistanceSquared(const TQ3Param2D *p1, const TQ3Param2D *p2);
float Q3Point3D_DistanceSquared(const TQ3Point3D *p1, const TQ3Point3D *p2);
float Q3RationalPoint3D_DistanceSquared (
const TQ3RationalPoint3D *p1, 
const TQ3RationalPoint3D *p2);
float Q3RationalPoint4D_DistanceSquared (
const TQ3RationalPoint4D *p1, 
const TQ3RationalPoint4D *p2);

Determining Point Relative Ratios

TQ3Point2D *Q3Point2D_RRatio(const TQ3Point2D *p1, 
const TQ3Point2D *p2, 
float r1, 
float r2, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_RRatio(const TQ3Param2D *p1, 
const TQ3Param2D *p2, 
float r1, 
float r2, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_RRatio(const TQ3Point3D *p1, 
const TQ3Point3D *p2, 
float r1, 
float r2, 
TQ3Point3D *result);
TQ3RationalPoint4D *Q3RationalPoint4D_RRatio (
const TQ3RationalPoint4D *p1, 
const TQ3RationalPoint4D *p2, 
float r1, 
float r2, 
TQ3RationalPoint4D *result);

Adding and Subtracting Points and Vectors

TQ3Point2D *Q3Point2D_Vector2D_Add (
const TQ3Point2D *point2D, 
const TQ3Vector2D *vector2D, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_Vector2D_Add (
const TQ3Param2D *param2D, 
const TQ3Vector2D *vector2D, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_Vector3D_Add (
const TQ3Point3D *point3D, 
const TQ3Vector3D *vector3D, 
TQ3Point3D *result);
TQ3Point2D *Q3Point2D_Vector2D_Subtract (
const TQ3Point2D *point2D, 
const TQ3Vector2D *vector2D, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_Vector2D_Subtract (
const TQ3Param2D *param2D, 
const TQ3Vector2D *vector2D, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_Vector3D_Subtract (
const TQ3Point3D *point3D, 
const TQ3Vector3D *vector3D, 
TQ3Point3D *result);

Scaling Vectors

TQ3Vector2D *Q3Vector2D_Scale(const TQ3Vector2D *vector2D, 
float scalar, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Scale(const TQ3Vector3D *vector3D, 
float scalar, 
TQ3Vector3D *result);

Determining the Lengths of Vectors

float Q3Vector2D_Length(const TQ3Vector2D *vector2D);
float Q3Vector3D_Length(const TQ3Vector3D *vector3D);

Normalizing Vectors

TQ3Vector2D *Q3Vector2D_Normalize (
const TQ3Vector2D *vector2D, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Normalize (
const TQ3Vector3D *vector3D, 
TQ3Vector3D *result);

Adding and Subtracting Vectors

TQ3Vector2D *Q3Vector2D_Add(const TQ3Vector2D *v1, 
const TQ3Vector2D *v2, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Add(const TQ3Vector3D *v1, 
const TQ3Vector3D *v2, 
TQ3Vector3D *result);
TQ3Vector2D *Q3Vector2D_Subtract (
const TQ3Vector2D *v1, 
const TQ3Vector2D *v2, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Subtract (
const TQ3Vector3D *v1, 
const TQ3Vector3D *v2, 
TQ3Vector3D *result);

Determining Vector Cross Products

float Q3Vector2D_Cross(const TQ3Vector2D *v1, 
const TQ3Vector2D *v2);
TQ3Vector3D *Q3Vector3D_Cross(const TQ3Vector3D *v1, 
const TQ3Vector3D *v2, 
TQ3Vector3D *result);
TQ3Vector3D *Q3Point3D_CrossProductTri (
const TQ3Point3D *point1, 
const TQ3Point3D *point2, 
const TQ3Point3D *point3, 
TQ3Vector3D *crossVector);

Determining Vector Dot Products

float Q3Vector2D_Dot(const TQ3Vector2D *v1, const TQ3Vector2D *v2);
float Q3Vector3D_Dot(const TQ3Vector3D *v1, const TQ3Vector3D *v2);

Transforming Points and Vectors

TQ3Vector2D *Q3Vector2D_Transform (
const TQ3Vector2D *vector2D, 
const TQ3Matrix3x3 *matrix3x3, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Transform (
const TQ3Vector3D *vector3D, 
const TQ3Matrix4x4 *matrix4x4, 
TQ3Vector3D *result);
TQ3Point2D *Q3Point2D_Transform (
const TQ3Point2D *point2D, 
const TQ3Matrix3x3 *matrix3x3, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_Transform (
const TQ3Param2D *param2D, 
const TQ3Matrix3x3 *matrix3x3, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_Transform (
const TQ3Point3D *point3D, 
const TQ3Matrix4x4 *matrix4x4, 
TQ3Point3D *result);
TQ3RationalPoint4D *Q3RationalPoint4D_Transform (
const TQ3RationalPoint4D *point4D, 
const TQ3Matrix4x4 *matrix4x4, 
TQ3RationalPoint4D *result);
TQ3Status Q3Point3D_To3DTransformArray (
const TQ3Point3D *inVertex, 
const TQ3Matrix4x4 *matrix, 
TQ3Point3D *outVertex, 
long numVertices, 
unsigned long inStructSize, 
unsigned long outStructSize);
TQ3Status Q3Point3D_To4DTransformArray (
const TQ3Point3D *inVertex, 
const TQ3Matrix4x4 *matrix, 
TQ3RationalPoint4D *outVertex, 
long numVertices, 
unsigned long inStructSize, 
unsigned long outStructSize);
TQ3Status Q3RationalPoint4D_To4DTransformArray (
const TQ3RationalPoint4D *inVertex, 
const TQ3Matrix4x4 *matrix, 
TQ3RationalPoint4D *outVertex, 
long numVertices, 
unsigned long inStructSize, 
unsigned long outStructSize);

Negating Vectors

TQ3Vector2D *Q3Vector2D_Negate(const TQ3Vector2D *vector2D, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Negate(const TQ3Vector3D *vector3D, 
TQ3Vector3D *result);

Converting Points from Cartesian to Polar or Spherical Form

TQ3PolarPoint *Q3Point2D_ToPolar (
const TQ3Point2D *point2D, 
TQ3PolarPoint *result);
TQ3Point2D *Q3PolarPoint_ToPoint2D (
const TQ3PolarPoint *polarPoint, 
TQ3Point2D *result);
TQ3SphericalPoint *Q3Point3D_ToSpherical (
const TQ3Point3D *point3D, 
TQ3SphericalPoint *result);
TQ3Point3D *Q3SphericalPoint_ToPoint3D (
const TQ3SphericalPoint *sphericalPoint, 
TQ3Point3D *result);

Determining Point Affine Combinations

TQ3Point2D *Q3Point2D_AffineComb (
const TQ3Point2D *points2D, 
const float *weights, 
unsigned long nPoints, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_AffineComb (
const TQ3Param2D *params2D, 
const float *weights, 
unsigned long nPoints, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_AffineComb (
const TQ3Point3D *points3D, 
const float *weights, 
unsigned long nPoints, 
TQ3Point3D *result);
TQ3RationalPoint3D *Q3RationalPoint3D_AffineComb (
const TQ3RationalPoint3D *points3D, 
const float *weights, 
unsigned long nPoints, 
TQ3RationalPoint3D *result);
TQ3RationalPoint4D *Q3RationalPoint4D_AffineComb (
const TQ3RationalPoint4D *points4D, 
const float *weights, 
unsigned long nPoints, 
TQ3RationalPoint4D *result);

Managing Matrices

TQ3Matrix3x3 *Q3Matrix3x3_Copy(const TQ3Matrix3x3 *matrix3x3, 
TQ3Matrix3x3 *result);
TQ3Matrix4x4 *Q3Matrix4x4_Copy(const TQ3Matrix4x4 *matrix4x4, 
TQ3Matrix4x4 *result);
TQ3Matrix3x3 *Q3Matrix3x3_SetIdentity (
TQ3Matrix3x3 *matrix3x3);
TQ3Matrix4x4 *Q3Matrix4x4_SetIdentity (
TQ3Matrix4x4 *matrix4x4);
TQ3Matrix3x3 *Q3Matrix3x3_Transpose (
const TQ3Matrix3x3 *matrix3x3, 
TQ3Matrix3x3 *result);
TQ3Matrix4x4 *Q3Matrix4x4_Transpose (
const TQ3Matrix4x4 *matrix4x4, 
TQ3Matrix4x4 *result);
TQ3Matrix3x3 *Q3Matrix3x3_Invert (
const TQ3Matrix3x3 *matrix3x3, 
TQ3Matrix3x3 *result);
TQ3Matrix4x4 *Q3Matrix4x4_Invert (
const TQ3Matrix4x4 *matrix4x4, 
TQ3Matrix4x4 *result);
TQ3Matrix3x3 *Q3Matrix3x3_Adjoint (
const TQ3Matrix3x3 *matrix3x3, 
TQ3Matrix3x3 *result);
TQ3Matrix3x3 *Q3Matrix3x3_Multiply (
const TQ3Matrix3x3 *matrixA, 
const TQ3Matrix3x3 *matrixB, 
TQ3Matrix3x3 *result);
TQ3Matrix4x4 *Q3Matrix4x4_Multiply (
const TQ3Matrix4x4 *matrixA, 
const TQ3Matrix4x4 *matrixB, 
TQ3Matrix4x4 *result);
float Q3Matrix3x3_Determinant(const TQ3Matrix3x3 *matrix3x3);
float Q3Matrix4x4_Determinant(const TQ3Matrix4x4 *matrix4x4);

Setting Up Transformation Matrices

TQ3Matrix3x3 *Q3Matrix3x3_SetTranslate (
TQ3Matrix3x3 *matrix3x3, 
float xTrans, 
float yTrans);
TQ3Matrix3x3 *Q3Matrix3x3_SetScale (
TQ3Matrix3x3 *matrix3x3, 
float xScale, 
float yScale);
TQ3Matrix3x3 *Q3Matrix3x3_SetRotateAboutPoint (
TQ3Matrix3x3 *matrix3x3, 
const TQ3Point2D *origin, 
float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetTranslate (
TQ3Matrix4x4 *matrix4x4, 
float xTrans, 
float yTrans, 
float zTrans);
TQ3Matrix4x4 *Q3Matrix4x4_SetScale (
TQ3Matrix4x4 *matrix4x4, 
float xScale, 
float yScale, 
float zScale);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotateAboutPoint (
TQ3Matrix4x4 *matrix4x4, 
const TQ3Point3D *origin, 
float xAngle, 
float yAngle, 
float zAngle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotateAboutAxis (
TQ3Matrix4x4 *matrix4x4, 
const TQ3Point3D *origin, 
const TQ3Vector3D *orientation, 
float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotate_X (
TQ3Matrix4x4 *matrix4x4, float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotate_Y (
TQ3Matrix4x4 *matrix4x4, float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotate_Z (
TQ3Matrix4x4 *matrix4x4, float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotate_XYZ (
TQ3Matrix4x4 *matrix4x4, 
float xAngle, 
float yAngle, 
float zAngle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotateVectorToVector (
TQ3Matrix4x4 *matrix4x4, 
const TQ3Vector3D *v1, 
const TQ3Vector3D *v2);
TQ3Matrix4x4 *Q3Matrix4x4_SetQuaternion (
TQ3Matrix4x4 *matrix, 
const TQ3Quaternion *quaternion);

Utility Functions

#define Q3Math_DegreesToRadians(x)  ((x) * kQ3Pi / 180.0)
#define Q3Math_RadiansToDegrees(x)  ((x) * 180.0 / kQ3Pi)
#define Q3Math_Min(x,y)             ((x) <= (y) ? (x) : (y))
#define Q3Math_Max(x,y)             ((x) >= (y) ? (x) : (y))

Managing Quaternions

TQ3Quaternion *Q3Quaternion_Set (
TQ3Quaternion *quaternion, 
float w, 
float x, 
float y, 
float z);
TQ3Quaternion *Q3Quaternion_SetIdentity (
TQ3Quaternion *quaternion);
TQ3Quaternion *Q3Quaternion_Copy (
const TQ3Quaternion *quaternion, 
TQ3Quaternion *result);
TQ3Boolean Q3Quaternion_IsIdentity (
const TQ3Quaternion *quaternion);
TQ3Quaternion *Q3Quaternion_Invert (
const TQ3Quaternion *quaternion, 
TQ3Quaternion *result);
TQ3Quaternion *Q3Quaternion_Normalize (
const TQ3Quaternion *quaternion, 
TQ3Quaternion *result);
float Q3Quaternion_Dot(const TQ3Quaternion *q1, 
const TQ3Quaternion *q2);
TQ3Quaternion *Q3Quaternion_Multiply (
const TQ3Quaternion *q1, 
const TQ3Quaternion *q2, 
TQ3Quaternion *result);
TQ3Quaternion *Q3Quaternion_SetRotateAboutAxis (
TQ3Quaternion *quaternion, 
const TQ3Vector3D *axis, 
float angle);
TQ3Quaternion *Q3Quaternion_SetRotateX (
TQ3Quaternion *quaternion, 
float angle);
TQ3Quaternion *Q3Quaternion_SetRotateY (
TQ3Quaternion *quaternion, 
float angle);
TQ3Quaternion *Q3Quaternion_SetRotateZ (
TQ3Quaternion *quaternion, 
float angle);
TQ3Quaternion *Q3Quaternion_SetRotateXYZ (
TQ3Quaternion *quaternion, 
float xAngle, 
float yAngle, 
float zAngle);
TQ3Quaternion *Q3Quaternion_SetMatrix (
TQ3Quaternion *quaternion, 
const TQ3Matrix4x4 *matrix);
TQ3Quaternion *Q3Quaternion_SetRotateVectorToVector (
TQ3Quaternion *quaternion, 
const TQ3Vector3D *v1, 
const TQ3Vector3D *v2);
TQ3Quaternion *Q3Quaternion_MatchReflection (
const TQ3Quaternion *q1, 
const TQ3Quaternion *q2, 
TQ3Quaternion *result);
TQ3Quaternion *Q3Quaternion_InterpolateFast (
const TQ3Quaternion *q1, 
const TQ3Quaternion *q2, 
float t, 
TQ3Quaternion *result);
TQ3Quaternion *Q3Quaternion_InterpolateLinear (
const TQ3Quaternion *q1, 
const TQ3Quaternion *q2, 
float t, 
TQ3Quaternion *result) ;
TQ3Vector3D *Q3Vector3D_TransformQuaternion (
const TQ3Vector3D *vector, 
const TQ3Quaternion *quaternion, 
TQ3Vector3D *result);
TQ3Point3D *Q3Point3D_TransformQuaternion (
const TQ3Point3D *point, 
const TQ3Quaternion *quaternion, 
TQ3Point3D *result);

Managing Bounding Boxes

TQ3BoundingBox *Q3BoundingBox_Copy (
const TQ3BoundingBox *src, 
TQ3BoundingBox *dest);
TQ3BoundingBox *Q3BoundingBox_Union (
const TQ3BoundingBox *v1, 
const TQ3BoundingBox *v2, 
TQ3BoundingBox *result);
TQ3BoundingBox *Q3BoundingBox_Set (
TQ3BoundingBox *bBox, 
const TQ3Point3D *min, 
const TQ3Point3D *max, 
TQ3Boolean isEmpty);
TQ3BoundingBox *Q3BoundingBox_UnionPoint3D (
const TQ3BoundingBox *bBox, 
const TQ3Point3D *pt3D, 
TQ3BoundingBox *result);
TQ3BoundingBox *Q3BoundingBox_UnionRationalPoint4D (
const TQ3BoundingBox *bBox, 
const TQ3RationalPoint4D *pt4D, 
TQ3BoundingBox *result);
TQ3BoundingBox *Q3BoundingBox_SetFromPoints3D (
TQ3BoundingBox *bBox, 
const TQ3Point3D *pts, 
unsigned long nPts, 
unsigned long structSize);
TQ3BoundingBox *Q3BoundingBox_SetFromRationalPoints4D (
TQ3BoundingBox *bBox, 
const TQ3RationalPoint4D *pts, 
unsigned long nPts, 
unsigned long structSize);

Managing Bounding Spheres

TQ3BoundingSphere *Q3BoundingSphere_Copy (
const TQ3BoundingSphere *src, 
TQ3BoundingSphere *dest);
TQ3BoundingSphere *Q3BoundingSphere_Union (
const TQ3BoundingSphere *s1, 
const TQ3BoundingSphere *s2, 
TQ3BoundingSphere *result);
TQ3BoundingSphere *Q3BoundingSphere_Set (
TQ3BoundingSphere *bSphere, 
const TQ3Point3D *origin, 
float radius, 
TQ3Boolean isEmpty);
TQ3BoundingSphere *Q3BoundingSphere_UnionPoint3D (
const TQ3BoundingSphere *bSphere, 
const TQ3Point3D *pt3D, 
TQ3BoundingSphere *result);
TQ3BoundingSphere *Q3BoundingSphere_UnionRationalPoint4D (
const TQ3BoundingSphere *bSphere, 
const TQ3RationalPoint4D *pt4D, 
TQ3BoundingSphere *result);
TQ3BoundingSphere *Q3BoundingSphere_SetFromPoints3D (
TQ3BoundingSphere *bSphere, 
const TQ3Point3D *pts, 
unsigned long nPts, 
unsigned long structSize);
TQ3BoundingSphere *Q3BoundingSphere_SetFromRationalPoints4D (
TQ3BoundingSphere *bSphere, 
const TQ3RationalPoint4D *pts, 
unsigned long nPts, 
unsigned long structSize);